home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / contrib / pdcurs22 / src / portable / outopts.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-26  |  9.8 KB  |  297 lines
  1. /*
  2. ***************************************************************************
  3. * This file comprises part of PDCurses. PDCurses is Public Domain software.
  4. * You may use this code for whatever purposes you desire. This software
  5. * is provided AS IS with NO WARRANTY whatsoever.
  6. * Should this software be used in another application, an acknowledgement
  7. * that PDCurses code is used would be appreciated, but is not mandatory.
  8. *
  9. * Any changes which you make to this software which may improve or enhance
  10. * it, should be forwarded to the current maintainer for the benefit of 
  11. * other users.
  12. *
  13. * The only restriction placed on this code is that no distribution of
  14. * modified PDCurses code be made under the PDCurses name, by anyone
  15. * other than the current maintainer.
  16. * 
  17. * See the file maintain.er for details of the current maintainer.
  18. ***************************************************************************
  19. */
  20. #define    CURSES_LIBRARY    1
  21. #include <curses.h>
  22.  
  23. /* undefine any macros for functions defined in this module */
  24. #undef    clearok
  25. #undef    idlok
  26. #undef    idcok
  27. #undef    immedok
  28. #undef    leaveok
  29. #undef    setscrreg
  30. #undef    wsetscrreg
  31. #undef    scrollok
  32. #undef    nl
  33. #undef    nonl
  34. #undef    raw_output
  35.  
  36. /* undefine any macros for functions called by this module if in debug mode */
  37. #ifdef PDCDEBUG
  38. #endif
  39.  
  40. #ifdef PDCDEBUG
  41. char *rcsid_outopts  = "$Id$";
  42. #endif
  43.  
  44. /*man-start*********************************************************************
  45.  
  46.   Name:                                                       outopts
  47.  
  48.   Synopsis:
  49.       int clearok(WINDOW *win, bool bf);
  50.       int idlok( WINDOW *win, bool bf );
  51.       int idcok( WINDOW *win, bool bf );
  52.   ***    int immedok( WINDOW *win, bool bf );
  53.       int leaveok( WINDOW *win, bool bf );
  54.       int setscrreg(int top, int bot);
  55.       int wsetscrreg(WINDOW *win, int top, int bot);
  56.       int scrollok(WINDOW *win, bool bf);
  57.       int nl(void);
  58.       int nonl(void);
  59.  
  60.       int raw_output(bool bf);
  61.  
  62.   X/Open Description:
  63.      With the clearok() routine, if bf is TRUE, the next call to 
  64.      wrefresh() with this window will clear the screen completely 
  65.      and redraw the entire screen.
  66.  
  67.      If idlok() is enabled (bf is TRUE), curses will use the insert/delete
  68.      line feature of terminals so equipped.  If disabled, curses will not
  69.      use this feature.  (The insert/delete character feature is always
  70.      used.)  This option should be enabled only if the application
  71.      needs insert/delete line; for example, for a screen editor.  It
  72.      is disabled by default because insert/delete line tends to be
  73.      visually annoying when used in applications where it isn't really
  74.      needed.  If insert/delete line cannot be used, curses will redraw
  75.      the changed portions of all lines.
  76.  
  77.      With the idcok() routine, if enabled (bf is TRUE), curses considers
  78.      using the hardware insert/delete character feature of terminals so 
  79.      equipped. This is enabled by default.
  80.  
  81.      Normally, the hardware cursor is left at the location of the
  82.      window being refreshed.  leaveok() allows the cursor to be
  83.      left whereever the update happens to leave it.  It is useful
  84.      for applications where the cursor is not used, since it reduces
  85.      the need for cursor motions.  If possible, the cursor is made
  86.      invisible when this option is enabled.
  87.  
  88.      The setscrreg() and wsetscrreg() functions allow the user to set 
  89.      a software scrolling region in a window.  The parameters 'top' 
  90.      and 'bot' are the line numbers of the top and bottom margin of the 
  91.      scrolling region.  (Line 0 is the top line of the window.)  If this 
  92.      option and scrollok() are enabled, an attempt to move off the bottom 
  93.      margin will cause all lines in the scrolling region to scroll up one 
  94.      line.  Only the text of the window is scrolled.
  95.  
  96.      The nl() function enables the translation of newline into a
  97.      carriage return and a line-feed on output, and a carriage return
  98.      is translated into a newline on input.  Initially, the translations
  99.      do occur.  By disabling these translations, curses is able to
  100.      make better use of the line-feed capability, resulting in faster
  101.      cursor motion.
  102.  
  103.      The nonl() function disables the translation of newline into a
  104.      carriage return and a line-feed on output, and a carriage return
  105.      is translated into a newline on input.  Initially, the translations
  106.      do occur.  By disabling these translations, curses is able to
  107.      make better use of the line-feed capability, resulting in faster
  108.      cursor motion.
  109.  
  110.   PDCurses Description:
  111.      idlok() and idcok() are provided for portability.  
  112.      This may have some value for the FLEXOS platform, but there is 
  113.      no code in PDCurses at this time (910725) that takes advantage 
  114.      of this.
  115.  
  116.      Though not explicitly stated, the cursor will be made visible
  117.      again, if leaveok() is passed a FALSE value.
  118.              (Frotz:911226 Comments?)
  119.  
  120.      The raw_output() routine enables the output of raw characters using 
  121.      the 'standard' *add* and *ins* curses functions.
  122.      To force 8 bit output and no translation of control characters,
  123.      invoke raw_output() with bf as TRUE.  To force 7 bit output and
  124.      translation of control characters, invoke raw_output() with bf
  125.      as FALSE.
  126.  
  127.   X/Open Return Value:
  128.      All functions return OK on success and ERR on error.
  129.  
  130.   X/Open Errors:
  131.      No errors are defined for this function.
  132.  
  133.   Portability                             X/Open    BSD    SYS V
  134.                                           Dec '88
  135.       clearok                               Y        Y       Y
  136.       idlok                                 Y        Y       Y
  137.       idcok                                 -        -      4.0
  138.       immedok                               -        -      4.0
  139.       leaveok                               Y        Y       Y
  140.       setscrreg                             Y        Y       Y
  141.       wsetscrreg                            Y        Y       Y
  142.       scrollok                              Y        Y       Y
  143.       nl                                    Y        Y       Y
  144.       nonl                                  Y        Y       Y
  145.       raw_output                            -        -       -
  146.  
  147. **man-end**********************************************************************/
  148.  
  149. /***********************************************************************/
  150. int    clearok(WINDOW *win, bool bf)
  151. /***********************************************************************/
  152. {
  153. #ifdef PDCDEBUG
  154.     if (trace_on) PDC_debug("clearok() - called\n");
  155. #endif
  156.  
  157.     if (win == (WINDOW *)NULL)
  158.         return( ERR );
  159.  
  160.     win->_clear = bf;
  161.     if( bf )
  162.         touchwin( win );
  163.  
  164.     return( OK );
  165. }
  166. /***********************************************************************/
  167. int    idlok( WINDOW *win, bool bf )
  168. /***********************************************************************/
  169. {
  170. #ifdef PDCDEBUG
  171.     if (trace_on) PDC_debug("idlok() - called\n");
  172. #endif
  173.  
  174.     win->_use_idl = bf;
  175.     return( OK );
  176. }
  177. /***********************************************************************/
  178. int    idcok( WINDOW *win, bool bf )
  179. /***********************************************************************/
  180. {
  181. #ifdef PDCDEBUG
  182.     if (trace_on) PDC_debug("idcok() - called\n");
  183. #endif
  184.  
  185.     win->_use_idc = bf;
  186.     return( OK );
  187. }
  188. /***********************************************************************/
  189. int    leaveok( WINDOW *win, bool bf )
  190. /***********************************************************************/
  191. {
  192. #ifdef PDCDEBUG
  193.     if (trace_on) PDC_debug("leaveok() - called\n");
  194. #endif
  195.  
  196.     if  ((win->_leave = bf) != 0)    PDC_cursor_off();
  197.     else                PDC_cursor_on();
  198.     return( OK );
  199. }
  200. /***********************************************************************/
  201. int    setscrreg(int top, int bottom)
  202. /***********************************************************************/
  203. {
  204. #ifdef PDCDEBUG
  205.     if (trace_on) PDC_debug("setscrreg() - called: top %d bottom %d\n",top,bottom);
  206. #endif
  207.  
  208.     if (stdscr == (WINDOW *)NULL)
  209.         return (ERR);
  210.  
  211.     if ((0 <= top) &&
  212.         (top <= stdscr->_cury) &&
  213.         (stdscr->_cury <= bottom) &&
  214.         (bottom < LINES))
  215.     {
  216.         stdscr->_tmarg = top;
  217.         stdscr->_bmarg = bottom;
  218.         return (OK);
  219.     }
  220.     else
  221.     {
  222.         return (ERR);
  223.     }
  224. }
  225. /***********************************************************************/
  226. int    wsetscrreg(WINDOW *win, int top, int bottom)
  227. /***********************************************************************/
  228. {
  229. #ifdef PDCDEBUG
  230.     if (trace_on) PDC_debug("wsetscrreg() - called: top %d bottom %d\n",top,bottom);
  231. #endif
  232.  
  233.     if (win == (WINDOW *)NULL)
  234.         return (ERR);
  235.  
  236.     if ((0 <= top) &&
  237.         (top <= win->_cury) &&
  238.         (win->_cury <= bottom) &&
  239.         (bottom < win->_maxy))
  240.     {
  241.         win->_tmarg = top;
  242.         win->_bmarg = bottom;
  243.         return (OK);
  244.     }
  245.     else
  246.     {
  247.         return (ERR);
  248.     }
  249. }
  250. /***********************************************************************/
  251. int    scrollok(WINDOW *win, bool bf)
  252. /***********************************************************************/
  253. {
  254. #ifdef PDCDEBUG
  255.     if (trace_on) PDC_debug("scrollok() - called\n");
  256. #endif
  257.  
  258.     if  (win == (WINDOW *)NULL)
  259.         return( ERR );
  260.  
  261.     win->_scroll    = bf;
  262.     return( OK );
  263. }
  264. /***********************************************************************/
  265. int    nl(void)
  266. /***********************************************************************/
  267. {
  268. #ifdef PDCDEBUG
  269.     if (trace_on) PDC_debug("nl() - called\n");
  270. #endif
  271.  
  272.     _cursvar.autocr = TRUE;
  273.     return( OK );
  274. }
  275. /***********************************************************************/
  276. int    nonl(void)
  277. /***********************************************************************/
  278. {
  279. #ifdef PDCDEBUG
  280.     if (trace_on) PDC_debug("nonl() - called\n");
  281. #endif
  282.  
  283.     _cursvar.autocr = FALSE;
  284.     return( OK );
  285. }
  286. /***********************************************************************/
  287. int    raw_output(bool bf)
  288. /***********************************************************************/
  289. {
  290. #ifdef PDCDEBUG
  291.     if (trace_on) PDC_debug("raw_output() - called\n");
  292. #endif
  293.  
  294.     _cursvar.raw_out = bf;
  295.     return( OK );
  296. }
  297.